googologywikiaorg-20200223-history
User blog:KthulhuHimself/Terminal array notation.
My search for a satisfying googological function is at a turning point, as several new discoveries of mine are quite possibly going to generalize and simplify, let alone propel the idea of TsN furthermore than ever before. I've been sitting on a couch, thinking, "A function's growth-speed can be increased by recursion, but what type of recursion would do that job best?" And came up with this. Terminal array Notation, not to be confused with Terminal string Notation, the former owner of that name, is defined as follows: Take a function f(n), and a base value n, and nest the function f(n) in the way the array describes. The following shows the first few arguments depicting TaN. Arguments and generalization (Feel free to skip this bit if you don't have the patience and think you can handle the doubtedly correct ruleset. If you have the time, read this. It will give you a better view of what TaN means.) <0> = f(n) <1> = f(f(n)) <2> = f(f(f(n))) = <0,1> = f(f(f(f(f(f(...(f(n)))))))))))) (n nestings) <1,1> = f(f(f(f(f(f(...(f(n)))))))))))) (<0,1> nestings) <2,1> = f(f(f(f(f(f(...(f(n)))))))))))) (<1,1> nestings) = f(f(f(f(f(f(...(f(n)))))))))))) ( nestings) ' = <0,2>' ' = <0,3>' ' = <0,m+1>' <0,n> = <0,0,1> <0,0,n> = <0,0,0,1> <0,0,0,...,0,n> (a zeroes) = <0,0,0,...,0,1> (a+1 zeroes) <0,0,0,...,0,1> (n zeroes) = <0,<1>> = <<1>> (As you can see, we are now using multiple brackets, keep note of this for later.) <1,<1>> = ' <0,0,0,...,0,1> (<0,0,0,...,0,1> (n zeroes) zeroes) '<2,<1>> = ' <0,0,0,...,0,1> (<0,0,0,...,0,1> (<0,0,0,...,0,1> (n zeroes) zeroes) zeroes) '<1>> = <0,1>,<1> = ' <0,0,0,...,0,1> (<0,0,0,...,0,1> (<0,0,0,...,0,1> (...............) zeroes) zeroes) nested n times '<1,1,<1>> ' = <0,0,0,...,0,1> (<0,0,0,...,0,1> (<0,0,0,...,0,1> (...............) zeroes) zeroes) nested (<0,0,0,...,0,1> (<0,0,0,...,0,1> (<0,0,0,...,0,1> (...............) zeroes) zeroes) nested n times) times '<0,0,0,...,0,1,<1>> (n zeroes) = ' <0>,<2> '<> = ' <<0,1>> '<<0,0,0,...,0,1>> = ' <<0>,<1>> '<<0>,> = ' <<0>,<0,1>> '<<0>,<0,0,0,...,0,1>> (n zeroes) = ' <<0>,<0>,<1>> '<<0>,<0>,.....<0>,<1> (n zeroes) = <<<1>>> In general, <<<...<<<1>>>...>>> (n cornered brackets) = <<<<...<<<0>>>...>>>, <<<...<<<0>>>...>>>,<<<...<<<0>>>...>>>,..................,<<<...<<<0>>>...>>>,<<<...<<<1>>>...>>> (n+1 entries with n-1 brackets) And so, ' <<<...<<<1>>>...>>> (n cornered brackets) = <0,,1> As you can see, we now have multiple commas. The terminology of additional commas works nearly identically to additional brackets. For a few more arguments, read as follows, if you think you understood the effect of, say, eight commas, skip this bit. '<<<<...<<<1>>>...>>>,,1> = <0,,2> <<<<...<<<1>>>...>>>,,m> = <0,,m+1> <0,,n> = <0,,0,1> <0,,0,0,0,...,0,1> (n+1 entries) = <0,,0,<1>> ... (and so on) <0,,0,<<<...<<<1>>>...>>>>> (n brackets) = <0,,0,,1> <0,,0,,0,<<<...<<<1>>>...>>>>> (n brackets) = <0,,0,,0,,1> <0,,0,,0,,...,,0,,1> (n+1 entries) = <0,,<1>> <0,,<0>,<<<...<<<1>>>...>>>> (n brackets) = <0,,<0>,0,,1> <0,,<0>,0,,0,,0,,...,,0,,1> (n+1 entries) = <0,,<0>,,<1>> <0,,<0>,,<0>,,<0>,,.....,,<0>,,<1>> = <0,,<<1>>> And to finish our definition: <0,,<<<...<<<1>>>...>>>> (n brackets) = <0,,,1> And so on, and so on, and so on, and so on, and so on, and so on,..... In a way, commas and brackets are the same thing, only commas refer to brackets, and brackets refer to entries. They are all seperators. Being so similar, why not generalize them?! These different seperators can be revised into an array of their own, for example, <0,,,<<1>>> can be traanslated into: <0<2,2>1> (we reduce the comma indicator by one, so that <0<0,0,1>1> can have a meaning), and ,say, <0,,<<<<1>>>>> can be translated into: <0<4,2>1>, and so on. In this way, <0<0,0,1>1> could be created. But what would <0<0,0,1>1> actually mean? Well, we know that <0,<<<...<<<1>>>...>>>> (n brackets) = <0,,1> or in short, <01> = <0<0,1>1>. Looks familiar? The same logic apllies to <0<0,0,1>1>. We have <0,,,,...,,,1> (n+1 commas), we get <0<0,0,1>1>. The seperator itself becomes an array! To make this even more generalized, its possible to translate this into: <0<0<0>0<0>1>1>. But that's a headache to look at. Lets stick to <0<0,0,1>1> for now. For those of you asking, yes, it is possible to make: <0<0<0<1>1>1>1>, <0<0<0<0<0<0<0<0<1>1>1>1>1>1>1>1>1>, and so on. Ruleset attempt It is possible to define a "simple" ruleset in order to ease out the understanding of the function, and my attempt at giving TaN solid rules will go as follows: Notes (# and #* represent the rest of the array) < will define the start of an array, or the start of a seperator array. > just the same as <, only it defines the end of an array. m can be any number, and is to be used as an entry. n is the starting value, and is to be defined before solving the array. f(n) is the starting function, and is to be defined before solving the array. <#,m#*> can be turned into <#<0>m#*> for whatever need (and vise versa). The array should formally be written as: f(n)<#>, f(n) being both the starting value and function. For example: 3!<0<23,4>4> Rules (incomplete) #f(n)<0> = f(n) #f(n) = f(f(n)) or f(f(f(f(f(f(...(f(n)))))) (m+1 nests) #'f(n) = f(n)<0<0>1>' #'f(n)<#> can be simplified to <#> (From now on, we'll use that form of the notation)' #'<#<0>n> = <#<0>0<0>1>' #'<0<0>0<0>0<0>...<0>0<0>1> = <0<1>1>' #'<000...01> = <01>' #'<01> = <0<0<0>1>1>' #'All the rules (3-8) for normal arrays apply to sperator arrays.' ' It is important to note that <1,1> is NOT equal to f(f(f(f(...f(f(n)))))) (f(n) nestings), but rather ''' f(f(f(f(...f(f(n)))))) ( f(f(f(f(...f(f(n)))))) (n nestings) nestings) '''Phew!! Seems right to me. If you have any questions, write them below in the comments. Extensions Parametrical-extended Terminal array Notation Well, this is the extensions bit, so I might as well try to devise some extension!! For starters, lets look at the strongest expression so far, <0<0<0...<0<0<1>1>1>...1>1>1> (n+1 nestings). Now, for each time some parameter was equal to "n", we always replaced it with 0, and increased a certain other parameter by one. In this expression, the numbers of nestings is n+1, so we hence need to replace n with 0, and-- wait, which parameter shall we increase? Oh, joy. We need to make another parameter. And if it wasn't obvious until now, said parameter will appear in the seperator. Lets define it as follows, <0<0<0...<0<0<1>1>1>...1>1>1> (n+1 nestings) = <0<<1>>1> As you can see, the seperator mart itself now inhibits an additional property, which can be expressed in the same way all the previous were expressed. For example, the above should be expressed: <0<<1>1>1>, with the uppercase number refering to the brackets, not to the seperator entry. As for ''' <0<<2>1>1>, we can only presume that it would be equal to: <0<<1><0<<1><0<<1>...<<1>1>...>1>1>1 (n nestings). For obvious reasons, <0<'1>1> is equal to <0<<0,1>1>1>.' '''But hey! the seperator mark itself now has a seperator of it's own! Could we simply apply the same logic of <0<0,1>1> = <0<0<0>1>1> on this case? Of course we could!! hence ' <0<<0,1>1>1> can be expressed as: <0<<0<0>1>1>1>. BAM!! We have an extension. Parametrical-extended Terminal array Notation (mark 2) Oh, yippie, another extension. Same as before, just this time, we'll be concentrating on''' <0<<0<<0<.....1>1>1>1>1>1> (n thingies).' '<0<''' <0<<0<.....1>1>1>1>1>1> (n thingies) = <01>1> <0< /<01>1>1>1>1> (n thingies) =<01>1> All hail repetetetetive definitions. 'Higher-order Terminal array Notation' This is the first meaningful extension beyond PeTaN, and will quite possibly propel the function to the Gamma-zero ordinal (or not). First, lets resurrect PeTaN(m2). Now as you probably remember, ''' <0<<0<<0<.....1>1>1>1>1>1> (n thingies) = <01>1> Expressing it like this is not bringing us much further than before, and hence we can only presume that it is possible to extend on the notation we used. First we will define: <01>1> = <0<<1><1>1>1>''' Oh, it seems we have another type of seperator-mark seperator. What can we assume? Well, lets just call this a "second-order" parameter extension. Naturally, this small parameter extension can be expressed as an array, so we can have: ' ' ' <0<<1>...<1><1><1>1>1> '''Lets define this as: ' <0<<1><1>1>1>, only this time, the parameter extension is of third-order (expressing this will require a new notation, the notation below will delve into the subject) '''A formal notation for this would be <0<<1><1>1>1>() But wait, could this be <0<<1><1>1>1>(<0,1>)? Would that make any sense? Well, from here on out, we'd have to define situations like <0<<1><1>1>1>(<1,1>), without it just meaning: <0<<1><1>1>1>(). We could take the example from PeTaN, <0<<1,1>1>1>, and infer. <0<<1><1>1>1>(<1,1>) should be equal to <0<<1><1>1>1>(), where m is <0<<1><1>1>1>(), where b is equal to... continue this series n times, ending with <0<<1><1>1>1>(), or <0<<1><1>1>1>(<0,1>) ''' 'We can clearly have<0<<1><1>1>1>(<0<<1><1>1>1>), can't we?' ' 'Dimensional Terminal array Notation 'First, define as follows:' '<0<<1><1>1>1>(<0<<1><1>1>1>(<0<<1><1>1>1>(......(<0<<1><1>1>1>))))))) (with n thingies) =' <0<1>1>{1}<1>' ' '<0<<1><1>1>1>(<0<<1><1>1>1>(<0<<1><1>1>1>(......(<0<<1><1>1>1>))))))){1}<1> (with n thingies) = <0<1>1>{1}<2> ' We now have a new array! Clearly, <0<1>1>{1}'<0<<1><1>1>1>(<0<<1><1>1>1>(<0<<1><1>1>1>(......(<0<<1><1>1>1>))))))){1}<1> (with n thingies) ='<0<1>1>{1}<0<1>1>{1}<1>.' ' We can see that {1} represents a dimensional jump, and so the rest should be quite obvious. Now what on earth could {2} mean? A 2-dimensional jump will work in a similar way to BEAF dimensional arrays. Or in other words, <0<1>1>{1}'<0<1>1>{1}<0<1>1>{1}......{1}<0<1>1> (n arrays) = <0<1>1>{2}<1>''' 'and: '' <0<1>1>{1} <0<1>1>{1}<0<1>1>{1}......{1}<0<1>1>{2}<1> (n arrays) = <0<1>1>{2}<2> '''The only reason I have devised this is so I can get to the next extension, ultradimensional arrays, which will be the base for TiTaN Notation. Superdimensional Terminal array Notation Now, now, we need to expand the previously denoted DTaN, and understand that it is identical to normal TaN. For starters, define: <0<1>1>{n}<1> = <0<1>1>{0,1}<1>. Recognize this? It might take moment to understand that <1> and {1} are two of the same thing. Repeating the logical connection between''' <0<<1><1>1>1> and <0<1>1>{1}<1>, we can get <0<1>1>{<0<1>1>{1}<1>}<1>, in this case, we have a dimensional break inside the dimensional break itself! Needless to say, <0<1>1>{<0<1>1>{<0<1>1>{...<0<1>1>{1}<1>...}<1>}<1>}<1> (n thingies) = <0<1>1>{<1>1}<1>, hence from here on out, we can refer to <> sperators as p=<1> (p standing for parameter) and to {} sperators as p=<2>. From this we can devise p=<3> seperators, and p= (which is the same as p=<0,1>) seperators, and, heck, even p=<0<1>1>{1}<1> seperators. Formal notation, you ask? Well, in this case we can use as follows:' <0<1>1> = <0<(P<1>)>1>, and, say, <0<1>1>{1}<1> = <0<(P<2>)>1>, and (Suppose that (1) is p=3),' ' '<0<1>1>{1}<1>(1)'' <0<1>1>{1}<1> = <0<(P<3>)>1> 'In general, '' <0<(P,<#>)>1> expresses a p=# superdimensional array. Ultradimensional Terminal array Notation First, lets see the limit of SdTaN. Now, in theory, we can have a <0<(P<0<(P<#>)>1>)>1> array, can we not? Why not a <0<(P<0<(P<0<(P<0<(P<...<0<(P<1>)>1>...'>)'>1>'' )>1>)>1 >'')>1> array?' ''' 'Of course, these obscurities need to be defined. The above should be a <0<(<1>P<1>)>1> array. A theoretical expansion would be <0<(PP<#>)>1>, but what would it mean? Your suggestions have helped me a lot, as I now have an idea of where to continue to. We left off at the <0<(<1>P<1>)>1> array. From here on, we should go to <0<(<1><1>P<1>(1))>1>. We then have <0<(P<0<1>1>{1}<1>)>1>. Onwards? The above can be expressed <0<(P<(P<2>)>)>1>. Extension is obvious. <0<(P<(P<(P<...(P<1>)...>)>)>)>1> (n Superdimensional hyperions) = <0<(PP<1>)>1> <0<(PP<1>)>1> seems to be pretty strong... But we need to define <0<(PP<2>)>1>. Would it be <0<(P<(P<(P<...(P<(PP<1>)>)...>)>)>)>1> (n Superdimensional hyperions)? Well, We'll keep that for now. Obviously, <0<(PP<(PP<(PP<...(PP<1>)...>)>)>)>1> (n Ultradimensional hyperions) = <0<(PPP<1>)>1> Multiple P's? Another parameter!! Basically, <0<(PPP...PPP<1>)>1> (m P's) = <0<(P()<1>)>1>. I can't think of any further extensions, yet I believe that any more extensions aren't even needed. Hence, I doubt this will have any end if continued. Second attempt at ruleset Undoubtedly, the previous ruleset is quite unclear, and possibly inacurate. Hence, I will try to redifine TaN in the ruleset(s) that follow(s). Notes # and #* represent the rest of the array < will define the start of an array, or the start of a seperator array. > is just the same as <, only it defines the end of an array. m and w can be any number, and is to be used as an entry. n is the starting value, and is to be defined before solving the array. f(n) is the starting function, and is to be defined before solving the array. <#,m#*> can be turned into <#<0>m#*> for whatever need (and vise versa). The array should formally be written as: f(n)<#>, f(n) being both the starting value and function. For example: 3!<0<23,4>4> The example above can be simplified to <0<23,4>4>, yet keep note that this is not a number, but rather a form of recursion. Regular TaN Rule A1. If the array is empty, or the only entry is zero, f(n)<> = f(n)<0> = f(n) Rule A2. If there is only one entry, f(n) = f(f(n)) Rule A3. If there is more than one entry, and all the seperators are zero, f(n)<#,0,1> = f(n)<#,n> (and vise versa) Rule A4. If the seperators are not equal to zero, yet still have only one entry, f(n)<01> = f(n)<000...1> (n seperators) Rule A5. If the seperators are arrays, apply the logic from Rule A4 PeTaN Note: The uppercase number is called a seperator-mark parameter (Smp), or a mark array Rule B1. f(n)<0<0<0...<0<0<1>1>1>...1>1>1> (n nested seperator arrays) = f(n)<0<<1>1>1> Rule B1\1. f(n)<0<<0<<0<...<1>...>1>1>1 (n nestings) = f(n)<0<1>1> Rule B2. If the Smp is equal to n, f(n)<0<1>1> = f(n)<0<<0,1>1>1> Rule B3. Smp's can be arrays of any sort, and are solved similarly. Milestones <0> <1> <0,1> <0,0,1> <0<1>1> <0<0,1>1> 0<<1>1>1> 0<<0,1>1>1> <01>1> <0<<1><1>1>1>(<1>) <0<1>1>{1}<1> <0<(P<0,1>)>1> <0<(P<0<(P<1>)>1>)>1> <0<(P<(P<1>)>)>1> (is actually much larger than the above) <0<(P(<0,1>)<1>)>1> RECENT DISCOVERIES!!! This is a part in which I will describe my latest findings, and hence will be constantly updated. *'I've recently dicovered that f(n)<0,1<<1>1>1> is actually VERY similar to BEAF tetrational arrays, and inhibits an nearly identical growth speed!!' ''' *'Nee'dless to say, f(n)<0,1<<2>1>1> is very similar to pentational arrays, and f(n)<0,1<<1,1>1>1> is very similar to expandal arrays, etc.' ' *<01>1> is als'o equivalent to n&n&n&...&n&n (n repeitions), or {n,n / 2}, in BEAF (shoutout to SpongeTechX, who stated that plexation (My first function on the wiki) is not equal to n&n&n&...&n&n (n repetitions). I did reach it after all!)' ' *Similarly, <01>1> is equivalent to {n,n / 3} in BEAF, and s'o is <0<<0,1><1>1>1>(<1>) to {n,n / n}.'' ' Notice Many of the extensions above may seem to be somewhat ill-defined, but keep in mind that they mostly count on logical connections to their predecessors, and hence can be solved normally. I am working on another ruleset, so keep in mind that updates will come. In addition, it is crucial to mention that TaN and all its extensions should be solved from simpler examples. For example, in order to solve 5!<3,7,2,90>, it is recommended to first solve 5!<0,0,1>, and then 5!<0,0,0,1>, and so on. ' ' Category:Blog posts